From 56d87537d1cd3870dcbf431cd004ac244ffdf84a Mon Sep 17 00:00:00 2001
From: "sos22@labyrinth.cl.cam.ac.uk" <sos22@labyrinth.cl.cam.ac.uk>
Date: Tue, 8 Jul 2003 12:48:48 +0000
Subject: [PATCH] bitkeeper revision 1.299 (3f0abdb0PTDH5mlRlFBRy97wZ-ii8w)

Whitespace fixes.
---
 BitKeeper/etc/ignore             |   2 +
 xen/drivers/block/xen_physdisk.c | 412 +++++++++++++++----------------
 2 files changed, 204 insertions(+), 210 deletions(-)

diff --git a/BitKeeper/etc/ignore b/BitKeeper/etc/ignore
index c0f477469e..e8cfff001c 100644
--- a/BitKeeper/etc/ignore
+++ b/BitKeeper/etc/ignore
@@ -431,3 +431,5 @@ tools/control/.checkstyle
 xenolinux-2.4.21-sparse/arch/xeno/drivers/block/xl_block.c~
 xenolinux-2.4.21-sparse/arch/xeno/drivers/block/xl_physdisk_proc.c.bak
 xenolinux-2.4.21-sparse/arch/xeno/drivers/block/xl_physdisk_proc.c~
+xen/drivers/block/xen_block.c~
+xen/drivers/block/xen_physdisk.c~
diff --git a/xen/drivers/block/xen_physdisk.c b/xen/drivers/block/xen_physdisk.c
index 2c7d7483b8..cef06ea2a8 100644
--- a/xen/drivers/block/xen_physdisk.c
+++ b/xen/drivers/block/xen_physdisk.c
@@ -22,43 +22,42 @@
    (device, start, end, mode) quads which say what it has access to,
    and we fake the logical view on top of that. */
 struct physdisk_ace {
-  struct list_head list;
+    struct list_head list;
 
-  unsigned short device;
-  unsigned short partition;
-  unsigned long start_sect;
-  unsigned long n_sectors;
-  int mode;
+    unsigned short device;
+    unsigned short partition;
+    unsigned long start_sect;
+    unsigned long n_sectors;
+    int mode;
 };
 
 /* Operation is a blkdev constant i.e. READ, WRITE, ... */
 /* Must be called with p->physdev_lock held. */
 static struct physdisk_ace *find_ace(const struct task_struct *p,
 				     unsigned short dev,
-				     unsigned long sect,
-				     int operation)
+				     unsigned long sect, int operation)
 {
-  struct list_head *cur_ace_head;
-  struct physdisk_ace *cur_ace;
-
-  list_for_each(cur_ace_head, &p->physdisk_aces) {
-    cur_ace = list_entry(cur_ace_head, struct physdisk_ace,
-			 list);
-    DPRINTK("Is [%lx, %lx) good for %lx?\n",
-	    cur_ace->start_sect, cur_ace->start_sect + cur_ace->n_sectors,
-	    sect);
-    if (sect >= cur_ace->start_sect &&
-	sect < cur_ace->start_sect + cur_ace->n_sectors &&
-	dev == cur_ace->device &&
-	((operation == READ && (cur_ace->mode & PHYSDISK_MODE_R)) ||
-	 (operation == WRITE && (cur_ace->mode & PHYSDISK_MODE_W)))) {
-      DPRINTK("Yes.\n");
-      return cur_ace;
-    } else {
-      DPRINTK("No.\n");
+    struct list_head *cur_ace_head;
+    struct physdisk_ace *cur_ace;
+
+    list_for_each(cur_ace_head, &p->physdisk_aces) {
+	cur_ace = list_entry(cur_ace_head, struct physdisk_ace, list);
+	DPRINTK("Is [%lx, %lx) good for %lx?\n",
+		cur_ace->start_sect,
+		cur_ace->start_sect + cur_ace->n_sectors, sect);
+	if (sect >= cur_ace->start_sect
+	    && sect < cur_ace->start_sect + cur_ace->n_sectors
+	    && dev == cur_ace->device
+	    && ((operation == READ && (cur_ace->mode & PHYSDISK_MODE_R))
+		|| (operation == WRITE
+		    && (cur_ace->mode & PHYSDISK_MODE_W)))) {
+	    DPRINTK("Yes.\n");
+	    return cur_ace;
+	} else {
+	    DPRINTK("No.\n");
+	}
     }
-  }
-  return NULL;
+    return NULL;
 }
 
 /* Hold the lock on entry, it remains held on exit. */
@@ -70,56 +69,53 @@ static void xen_physdisk_revoke_access(unsigned short dev,
 				       unsigned long n_sectors,
 				       struct task_struct *p)
 {
-  /* Find every ace which intersects [start_sect, start_sect +
-     n_sectors] and either remove it completely or truncate it
-     down. */
-  struct list_head *cur_ace_head;
-  struct physdisk_ace *cur_ace, *new_ace;
-  unsigned long kill_zone_end, ace_end;
-
-  kill_zone_end = start_sect + n_sectors;
-  list_for_each(cur_ace_head, &p->physdisk_aces) {
-    cur_ace = list_entry(cur_ace_head, struct physdisk_ace,
-			 list);
-    ace_end = cur_ace->start_sect + cur_ace->n_sectors;
-    if (cur_ace->start_sect >= kill_zone_end ||
-	ace_end <= start_sect ||
-	cur_ace->device != dev)
-      continue;
-    
-    DPRINTK("Killing ace [%lx, %lx) against kill zone [%lx, %lx)\n",
-	    cur_ace->start_sect, ace_end, start_sect, kill_zone_end);
-
-    if (cur_ace->start_sect >= start_sect &&
-	ace_end <= kill_zone_end) {
-      /* ace entirely within kill zone -> kill it */
-      list_del(cur_ace_head);
-      cur_ace_head = cur_ace_head->prev;
-      kfree(cur_ace);
-    } else if (ace_end <= kill_zone_end) {
-      /* ace start before kill start, ace end in kill zone, 
-	 move ace end. */
-      cur_ace->n_sectors = start_sect - cur_ace->start_sect;
-    } else if (cur_ace->start_sect >= start_sect) {
-      /* ace start after kill start, ace end outside kill zone,
-	 move ace start. */
-      cur_ace->start_sect = kill_zone_end;
-      cur_ace->n_sectors = ace_end - cur_ace->start_sect;
-    } else {
-      /* The fun one: the ace entirely includes the kill zone. */
-      /* Cut the current ace down to just the bit before the kzone,
-	 create a new ace for the bit just after it. */ 
-      new_ace = kmalloc(sizeof(*cur_ace), GFP_KERNEL);
-      new_ace->device = dev;
-      new_ace->start_sect = kill_zone_end;
-      new_ace->n_sectors = ace_end - kill_zone_end;
-      new_ace->mode = cur_ace->mode;
-
-      cur_ace->n_sectors = start_sect - cur_ace->start_sect;
-
-      list_add(&new_ace->list, cur_ace_head);
+    /* Find every ace which intersects [start_sect, start_sect +
+       n_sectors] and either remove it completely or truncate it
+       down. */
+    struct list_head *cur_ace_head;
+    struct physdisk_ace *cur_ace, *new_ace;
+    unsigned long kill_zone_end, ace_end;
+
+    kill_zone_end = start_sect + n_sectors;
+    list_for_each(cur_ace_head, &p->physdisk_aces) {
+	cur_ace = list_entry(cur_ace_head, struct physdisk_ace, list);
+	ace_end = cur_ace->start_sect + cur_ace->n_sectors;
+	if (cur_ace->start_sect >= kill_zone_end ||
+	    ace_end <= start_sect || cur_ace->device != dev)
+	    continue;
+
+	DPRINTK("Killing ace [%lx, %lx) against kill zone [%lx, %lx)\n",
+		cur_ace->start_sect, ace_end, start_sect, kill_zone_end);
+
+	if (cur_ace->start_sect >= start_sect && ace_end <= kill_zone_end) {
+	    /* ace entirely within kill zone -> kill it */
+	    list_del(cur_ace_head);
+	    cur_ace_head = cur_ace_head->prev;
+	    kfree(cur_ace);
+	} else if (ace_end <= kill_zone_end) {
+	    /* ace start before kill start, ace end in kill zone, 
+	       move ace end. */
+	    cur_ace->n_sectors = start_sect - cur_ace->start_sect;
+	} else if (cur_ace->start_sect >= start_sect) {
+	    /* ace start after kill start, ace end outside kill zone,
+	       move ace start. */
+	    cur_ace->start_sect = kill_zone_end;
+	    cur_ace->n_sectors = ace_end - cur_ace->start_sect;
+	} else {
+	    /* The fun one: the ace entirely includes the kill zone. */
+	    /* Cut the current ace down to just the bit before the kzone,
+	       create a new ace for the bit just after it. */
+	    new_ace = kmalloc(sizeof(*cur_ace), GFP_KERNEL);
+	    new_ace->device = dev;
+	    new_ace->start_sect = kill_zone_end;
+	    new_ace->n_sectors = ace_end - kill_zone_end;
+	    new_ace->mode = cur_ace->mode;
+
+	    cur_ace->n_sectors = start_sect - cur_ace->start_sect;
+
+	    list_add(&new_ace->list, cur_ace_head);
+	}
     }
-  }
 }
 
 /* Hold the lock on entry, it remains held on exit. */
@@ -127,159 +123,155 @@ static int xen_physdisk_grant_access(unsigned short dev,
 				     unsigned short partition,
 				     unsigned long start_sect,
 				     unsigned long n_sectors,
-				     int mode,
-				     struct task_struct *p)
+				     int mode, struct task_struct *p)
 {
-  struct physdisk_ace *cur_ace;
-
-  /* Make sure it won't overlap with any existing ACEs. */
-  /* XXX this isn't quite right if the domain already has read access
-     and we try to grant write access, or vice versa. */
-  xen_physdisk_revoke_access(dev, start_sect, n_sectors, p);
-  
-  if (mode) {
-    cur_ace = kmalloc(sizeof(*cur_ace), GFP_KERNEL);
-    cur_ace->device = dev;
-    cur_ace->start_sect = start_sect;
-    cur_ace->n_sectors = n_sectors;
-    cur_ace->mode = mode;
-    cur_ace->partition = partition;
-
-    list_add_tail(&cur_ace->list, &p->physdisk_aces);
-  }
-
-  return 0;
+    struct physdisk_ace *cur_ace;
+
+    /* Make sure it won't overlap with any existing ACEs. */
+    /* XXX this isn't quite right if the domain already has read access
+       and we try to grant write access, or vice versa. */
+    xen_physdisk_revoke_access(dev, start_sect, n_sectors, p);
+
+    if (mode) {
+	cur_ace = kmalloc(sizeof(*cur_ace), GFP_KERNEL);
+	cur_ace->device = dev;
+	cur_ace->start_sect = start_sect;
+	cur_ace->n_sectors = n_sectors;
+	cur_ace->mode = mode;
+	cur_ace->partition = partition;
+
+	list_add_tail(&cur_ace->list, &p->physdisk_aces);
+    }
+
+    return 0;
 }
 
-static void xen_physdisk_probe_access(physdisk_probebuf_t *buf,
+static void xen_physdisk_probe_access(physdisk_probebuf_t * buf,
 				      struct task_struct *p)
 {
-  int max_aces;
-  int n_aces;
-  struct list_head *cur_ace_head;
-  struct physdisk_ace *cur_ace;
-  int x = 0;
-
-  max_aces = buf->n_aces;
-  n_aces = 0;
-  list_for_each(cur_ace_head, &p->physdisk_aces) {
-    x++;
-    if (x >= buf->start_ind) {
-      cur_ace = list_entry(cur_ace_head, struct physdisk_ace,
-			   list);
-      buf->entries[n_aces].device = cur_ace->device;
-      buf->entries[n_aces].partition = cur_ace->partition;
-      buf->entries[n_aces].start_sect = cur_ace->start_sect;
-      buf->entries[n_aces].n_sectors = cur_ace->n_sectors;
-      buf->entries[n_aces].mode = cur_ace->mode;
-      n_aces++;
-      if (n_aces >= max_aces)
-	break;
+    int max_aces;
+    int n_aces;
+    struct list_head *cur_ace_head;
+    struct physdisk_ace *cur_ace;
+    int x = 0;
+
+    max_aces = buf->n_aces;
+    n_aces = 0;
+    list_for_each(cur_ace_head, &p->physdisk_aces) {
+	x++;
+	if (x >= buf->start_ind) {
+	    cur_ace = list_entry(cur_ace_head, struct physdisk_ace, list);
+	    buf->entries[n_aces].device = cur_ace->device;
+	    buf->entries[n_aces].partition = cur_ace->partition;
+	    buf->entries[n_aces].start_sect = cur_ace->start_sect;
+	    buf->entries[n_aces].n_sectors = cur_ace->n_sectors;
+	    buf->entries[n_aces].mode = cur_ace->mode;
+	    n_aces++;
+	    if (n_aces >= max_aces)
+		break;
+	}
     }
-  }
-  buf->n_aces = n_aces;
+    buf->n_aces = n_aces;
 }
 
-int xen_physdisk_grant(xp_disk_t *xpd_in)
+int xen_physdisk_grant(xp_disk_t * xpd_in)
 {
-  struct task_struct *p;
-  xp_disk_t *xpd = map_domain_mem(virt_to_phys(xpd_in));
-  int res;
-
-  p = current;
-  DPRINTK("Have current.\n");
-  DPRINTK("Target domain %x\n", xpd->domain);
-
-  p = find_domain_by_id(xpd->domain);
-  if (p == NULL) {
-    DPRINTK("Bad domain!\n");
-    res = 1;
-    goto out;
-  }
-  spin_lock(&p->physdev_lock);
-  res = xen_physdisk_grant_access(xpd->device,
-				  xpd->partition,
-				  xpd->start_sect,
-				  xpd->n_sectors,
-				  xpd->mode,
-				  p);
-  spin_unlock(&p->physdev_lock);
-  put_task_struct(p);
-
- out:
-  unmap_domain_mem(xpd);
-  return res;
-}
+    struct task_struct *p;
+    xp_disk_t *xpd = map_domain_mem(virt_to_phys(xpd_in));
+    int res;
+
+    p = current;
+    DPRINTK("Have current.\n");
+    DPRINTK("Target domain %x\n", xpd->domain);
+
+    p = find_domain_by_id(xpd->domain);
+    if (p == NULL) {
+	DPRINTK("Bad domain!\n");
+	res = 1;
+	goto out;
+    }
+    spin_lock(&p->physdev_lock);
+    res = xen_physdisk_grant_access(xpd->device,
+				    xpd->partition,
+				    xpd->start_sect,
+				    xpd->n_sectors, xpd->mode, p);
+    spin_unlock(&p->physdev_lock);
+    put_task_struct(p);
 
-int xen_physdisk_probe(struct task_struct *requesting_domain,
-		       physdisk_probebuf_t *buf_in)
-{
-  struct task_struct *p;
-  physdisk_probebuf_t *buf = map_domain_mem(virt_to_phys(buf_in));
-  int res;
-
-  if (requesting_domain->domain != 0 &&
-      requesting_domain->domain != buf->domain) {
-    res = 1;
-    goto out;
-  }
-
-  p = find_domain_by_id(buf->domain);
-  if (p == NULL) {
-    res = 1;
-    goto out;
-  }
-
-  spin_lock(&p->physdev_lock);
-  xen_physdisk_probe_access(buf, p);
-  spin_unlock(&p->physdev_lock);
-  put_task_struct(p);
-
-  res = 0;
- out:
-  unmap_domain_mem(buf);
-  return res;
+  out:
+    unmap_domain_mem(xpd);
+    return res;
 }
 
-int xen_physdisk_access_okay(phys_seg_t *pseg, struct task_struct *p,
-			     int operation)
+int xen_physdisk_probe(struct task_struct *requesting_domain,
+		       physdisk_probebuf_t * buf_in)
 {
-  struct physdisk_ace *cur_ace;
-  unsigned long sect;
+    struct task_struct *p;
+    physdisk_probebuf_t *buf = map_domain_mem(virt_to_phys(buf_in));
+    int res;
+
+    if (requesting_domain->domain != 0 &&
+	requesting_domain->domain != buf->domain) {
+	res = 1;
+	goto out;
+    }
 
-  DPRINTK("Checking access for domain %d, start sect 0x%lx, length 0x%x.\n",
-	  p->domain, pseg->sector_number, pseg->nr_sects);
+    p = find_domain_by_id(buf->domain);
+    if (p == NULL) {
+	res = 1;
+	goto out;
+    }
 
-  for (sect = pseg->sector_number;
-       sect < pseg->sector_number + pseg->nr_sects;
-       ) {
-    /* XXX this would be a lot faster if the aces were sorted on start
-       address.  Also in revoke_access. */
     spin_lock(&p->physdev_lock);
-    cur_ace = find_ace(p, pseg->dev, sect, operation);
+    xen_physdisk_probe_access(buf, p);
     spin_unlock(&p->physdev_lock);
-    if (!cur_ace) {
-      /* Default closed. */
-      return 0;
+    put_task_struct(p);
+
+    res = 0;
+  out:
+    unmap_domain_mem(buf);
+    return res;
+}
+
+int xen_physdisk_access_okay(phys_seg_t * pseg, struct task_struct *p,
+			     int operation)
+{
+    struct physdisk_ace *cur_ace;
+    unsigned long sect;
+
+    DPRINTK
+	("Checking access for domain %d, start sect 0x%lx, length 0x%x.\n",
+	 p->domain, pseg->sector_number, pseg->nr_sects);
+
+    for (sect = pseg->sector_number;
+	 sect < pseg->sector_number + pseg->nr_sects;) {
+	/* XXX this would be a lot faster if the aces were sorted on start
+	   address.  Also in revoke_access. */
+	spin_lock(&p->physdev_lock);
+	cur_ace = find_ace(p, pseg->dev, sect, operation);
+	spin_unlock(&p->physdev_lock);
+	if (!cur_ace) {
+	    /* Default closed. */
+	    return 0;
+	}
+	sect +=
+	    MAX(cur_ace->n_sectors,
+		pseg->nr_sects + pseg->sector_number - sect);
     }
-    sect += MAX(cur_ace->n_sectors, pseg->nr_sects + pseg->sector_number - sect);
-  }
-  return 1;
+    return 1;
 }
 
 void destroy_physdisk_aces(struct task_struct *p)
 {
-  struct list_head *cur_ace_head, *next_head;
-  struct physdisk_ace *cur_ace;
-
-  spin_lock(&p->physdev_lock); /* We never release this again. */
-
-  for (cur_ace_head = p->physdisk_aces.next;
-       cur_ace_head != &p->physdisk_aces;
-       cur_ace_head = next_head) {
-    cur_ace = list_entry(cur_ace_head, struct physdisk_ace,
-			 list);
-    next_head = cur_ace_head->next;
-    kfree(cur_ace);
-  }
+    struct list_head *cur_ace_head, *next_head;
+    struct physdisk_ace *cur_ace;
+
+    spin_lock(&p->physdev_lock);	/* We never release this again. */
+
+    for (cur_ace_head = p->physdisk_aces.next;
+	 cur_ace_head != &p->physdisk_aces; cur_ace_head = next_head) {
+	cur_ace = list_entry(cur_ace_head, struct physdisk_ace, list);
+	next_head = cur_ace_head->next;
+	kfree(cur_ace);
+    }
 }
-- 
2.30.2